JavaScript-da bir vaqtda bajarish: Parallel vazifa bajaruvchilarni ishga tushirish

An'anaviy ravishda bir oqimli til sifatida tanilgan JavaScript, bir vaqtda ishlashni (concurrency) qabul qilish uchun rivojlandi, bu esa dasturchilarga bir nechta vazifalarni bir vaqtning o'zida bajarish imkonini beradi. Bu, ayniqsa, I/O bilan bog'liq operatsiyalar, murakkab hisob-kitoblar yoki ma'lumotlarni qayta ishlash bilan shug'ullanadigan sezgir va samarali veb-ilovalar yaratish uchun juda muhimdir. Bunga erishishning kuchli usullaridan biri parallel vazifa bajaruvchilari orqalidir.

JavaScript-da bir vaqtda ishlashni tushunish

Parallel vazifa bajaruvchilarga sho'ng'ishdan oldin, keling, JavaScript kontekstida bir vaqtda ishlash (concurrency) va parallellik (parallelism) tushunchalariga oydinlik kiritaylik.

• Bir vaqtda ishlash (Concurrency): Dasturning bir vaqtning o'zida bir nechta vazifani boshqarish qobiliyatini anglatadi. Vazifalar bir vaqtda bajarilmasligi mumkin, lekin dastur ular o'rtasida almashinib, parallellik illyuziyasini yaratadi. Bunga ko'pincha asinxron dasturlash va hodisalar tsikli (event loops) kabi usullar yordamida erishiladi.
• Parallellik (Parallelism): Bir nechta vazifalarni turli protsessor yadrolarida bir vaqtning o'zida haqiqiy bajarilishini o'z ichiga oladi. Bu ko'p yadroli muhitni va vazifalarni ushbu yadrolar bo'ylab taqsimlash mexanizmini talab qiladi.

JavaScript-ning hodisalar tsikli bir vaqtda ishlashni ta'minlasa-da, haqiqiy parallellikka erishish uchun yanada ilg'or usullar talab etiladi. Aynan shu yerda parallel vazifa bajaruvchilar ishga tushadi.

Parallel vazifa bajaruvchilar bilan tanishuv

Parallel vazifa bajaruvchi - bu vazifalarni bir nechta oqimlar yoki jarayonlar bo'ylab taqsimlash imkonini beruvchi vosita yoki kutubxona bo'lib, haqiqiy parallel bajarishni ta'minlaydi. Bu JavaScript ilovalarining ish unumdorligini sezilarli darajada yaxshilashi mumkin, ayniqsa hisoblash talab qiladigan yoki I/O bilan bog'liq operatsiyalarni o'z ichiga olgan ilovalarda. Ularning nima uchun muhimligini quyida ko'rib chiqamiz:

• Yaxshilangan unumdorlik: Vazifalarni bir nechta yadrolar bo'ylab taqsimlash orqali parallel vazifa bajaruvchilar dasturning umumiy bajarilish vaqtini qisqartirishi mumkin.
• Yaxshilangan sezgirlik: Uzoq davom etadigan vazifalarni alohida oqimlarga o'tkazish asosiy oqimning bloklanishini oldini oladi va silliq hamda sezgir foydalanuvchi interfeysini ta'minlaydi.
• Masshtablanuvchanlik: Parallel vazifa bajaruvchilar ilovangizni ko'p yadroli protsessorlardan foydalanish uchun masshtablash imkonini beradi, bu esa ko'proq ishni bajarish qobiliyatini oshiradi.

JavaScript-da parallel vazifalarni bajarish usullari

JavaScript parallel vazifalarni bajarishning bir nechta usullarini taklif etadi, ularning har biri o'zining kuchli va zaif tomonlariga ega:

1. Web Workers

Web Workers - bu asosiy oqimdan alohida, fon oqimlarida JavaScript kodini ishga tushirish imkonini beruvchi standart brauzer API'sidir. Bu foydalanuvchi interfeysini bloklamasdan hisoblash talab qiladigan vazifalarni bajarish uchun keng tarqalgan yondashuvdir.

Misol:

            // Asosiy oqim (index.html yoki script.js)
const worker = new Worker('worker.js');

worker.onmessage = (event) => {
 console.log('worker\'dan xabar olindi:', event.data);
};

worker.postMessage({ task: 'calculateSum', numbers: [1, 2, 3, 4, 5] });

// Worker oqimi (worker.js)
self.onmessage = (event) => {
 const data = event.data;
 if (data.task === 'calculateSum') {
 const sum = data.numbers.reduce((acc, val) => acc + val, 0);
 self.postMessage({ result: sum });
 }
};

            

              
                Copy
              
            
          

Afzalliklari:

• Standart brauzer API
• Asosiy vazifalar uchun foydalanish oson
• Asosiy oqimning bloklanishini oldini oladi

Kamchiliklari:

• DOM (Document Object Model) ga cheklangan kirish
• Oqimlar o'rtasida aloqa uchun xabar almashishni talab qiladi
• Murakkab vazifalar bog'liqliklarini boshqarish qiyin bo'lishi mumkin

Global qo'llash misoli: Dunyo bo'ylab moliyaviy tahlilchilar tomonidan qo'llaniladigan veb-ilovani tasavvur qiling. Aksiya narxlari va portfel tahlili uchun hisob-kitoblar Web Workers'ga yuklanishi mumkin, bu esa bir necha soniya davom etishi mumkin bo'lgan murakkab hisob-kitoblar paytida ham sezgir UI'ni ta'minlaydi. Tokio, London yoki Nyu-Yorkdagi foydalanuvchilar doimiy va unumdor tajribaga ega bo'lishadi.

2. Node.js Worker Threads

Web Workers'ga o'xshab, Node.js Worker Threads JavaScript kodini Node.js muhitida alohida oqimlarda bajarish imkonini beradi. Bu bir vaqtda so'rovlarni bajarishi yoki fon rejimida qayta ishlashni amalga oshirishi kerak bo'lgan server tomonidagi ilovalarni yaratish uchun foydalidir.

Misol:

            // Asosiy oqim (index.js)
const { Worker } = require('worker_threads');

const worker = new Worker('./worker.js');

worker.on('message', (message) => {
 console.log('worker\'dan xabar olindi:', message);
});

worker.postMessage({ task: 'calculateFactorial', number: 10 });

// Worker oqimi (worker.js)
const { parentPort } = require('worker_threads');

parentPort.on('message', (message) => {
 if (message.task === 'calculateFactorial') {
 const factorial = calculateFactorial(message.number);
 parentPort.postMessage({ result: factorial });
 }
});

function calculateFactorial(n) {
 if (n === 0) {
 return 1;
 }
 return n * calculateFactorial(n - 1);
}

            

              
                Copy
              
            
          

Afzalliklari:

• Node.js ilovalarida haqiqiy parallellikka imkon beradi
• Asosiy oqim bilan xotirani bo'lishadi (ehtiyotkorlik bilan, TypedArrays va o'tkaziladigan obyektlardan foydalanib ma'lumotlar poygasini oldini olish)
• CPU bilan bog'liq vazifalar uchun mos keladi

Kamchiliklari:

• Bir oqimli Node.js bilan solishtirganda sozlash murakkabroq
• Umumiy xotirani ehtiyotkorlik bilan boshqarishni talab qiladi
• Agar to'g'ri ishlatilmasa, poyga holatlari va turg'unliklarni keltirib chiqarishi mumkin

Global qo'llash misoli: Dunyo bo'ylab mijozlarga xizmat ko'rsatadigan elektron tijorat platformasini ko'rib chiqing. Mahsulot ro'yxatlari uchun rasmlarning hajmini o'zgartirish yoki qayta ishlash Node.js Worker Threads yordamida amalga oshirilishi mumkin. Bu Janubi-Sharqiy Osiyo yoki Janubiy Amerikaning ba'zi qismlari kabi sekin internet aloqasiga ega bo'lgan hududlardagi foydalanuvchilar uchun tez yuklanish vaqtini ta'minlaydi va asosiy server oqimining kiruvchi so'rovlarni qayta ishlash qobiliyatiga ta'sir qilmaydi.

3. Klasterlar (Node.js)

Node.js klaster moduli turli protsessor yadrolarida ishlaydigan ilovangizning bir nechta nusxalarini yaratish imkonini beradi. Bu kiruvchi so'rovlarni bir nechta jarayonlar bo'ylab taqsimlash imkonini beradi va ilovangizning umumiy o'tkazuvchanlik qobiliyatini oshiradi.

Misol:

            // index.js
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
 console.log(`Master ${process.pid} ishga tushdi`);

 // worker'larni ishga tushirish.
 for (let i = 0; i < numCPUs; i++) {
 cluster.fork();
 }

 cluster.on('exit', (worker, code, signal) => {
 console.log(`worker ${worker.process.pid} to'xtadi`);
 });
} else {
 // Worker'lar har qanday TCP ulanishini bo'lishishi mumkin
 // Bu holatda bu HTTP server
 http.createServer((req, res) => {
 res.writeHead(200);
 res.end('salom dunyo\n');
 }).listen(8000);

 console.log(`Worker ${process.pid} ishga tushdi`);
}

            

              
                Copy
              
            
          

Afzalliklari:

• Sozlash va ishlatish oson
• Ish yukini bir nechta jarayonlar bo'ylab taqsimlaydi
• Ilovaning o'tkazuvchanlik qobiliyatini oshiradi

Kamchiliklari:

• Har bir jarayon o'zining xotira maydoniga ega
• So'rovlarni taqsimlash uchun yuk dengeleyicisi (load balancer) talab qilinadi
• Jarayonlar o'rtasidagi aloqa murakkabroq bo'lishi mumkin

Global qo'llash misoli: Global kontent yetkazib berish tarmog'i (CDN) butun dunyodagi foydalanuvchilardan kelib tushadigan katta miqdordagi so'rovlarni qayta ishlash uchun Node.js klasterlaridan foydalanishi mumkin. So'rovlarni bir nechta jarayonlar bo'ylab taqsimlash orqali CDN foydalanuvchining joylashuvi yoki trafik hajmidan qat'i nazar, kontentni tez va samarali yetkazib berilishini ta'minlay oladi.

4. Xabarlar navbati (masalan, RabbitMQ, Kafka)

Xabarlar navbati vazifalarni bir-biridan ajratish va ularni bir nechta ishchilar (workers) bo'ylab taqsimlashning kuchli usulidir. Bu, ayniqsa, asinxron operatsiyalarni bajarish va masshtablanuvchi tizimlarni yaratish uchun foydalidir.

Konseptsiya:

• Ishlab chiqaruvchi (producer) xabarlarni navbatga yuboradi.
• Bir nechta ishchilar (workers) navbatdan xabarlarni iste'mol qiladi.
• Xabarlar navbati xabarlarning taqsimlanishini boshqaradi va har bir xabar faqat bir marta (yoki kamida bir marta) qayta ishlanishini ta'minlaydi.

Misol (Konseptual):

            // Ishlab chiqaruvchi (masalan, veb-server)
const amqp = require('amqplib');

async function publishMessage(message) {
 const connection = await amqp.connect('amqp://localhost');
 const channel = await connection.createChannel();

 const queue = 'task_queue';
 await channel.assertQueue(queue, { durable: true });
 channel.sendToQueue(queue, Buffer.from(JSON.stringify(message)), { persistent: true });
 console.log(" [x] Yuborildi '%s'", message);

 setTimeout(function() { connection.close(); process.exit(0) }, 500);
}

// Bajaruvchi (masalan, fon protsessori)
async function consumeMessage() {
 const connection = await amqp.connect('amqp://localhost');
 const channel = await connection.createChannel();

 const queue = 'task_queue';
 await channel.assertQueue(queue, { durable: true });
 channel.prefetch(1);
 console.log(" [x] %s navbatida xabarlarni kutmoqda. Chiqish uchun CTRL+C bosing", queue);
 channel.consume(queue, function(msg) {
 const secs = msg.content.toString().split('.').length - 1;

 console.log(" [x] Qabul qilindi %s", msg.content.toString());
 setTimeout(function() {
 console.log(" [x] Bajarildi");
 channel.ack(msg);
 }, secs * 1000);
 }, { noAck: false });
}

            

              
                Copy
              
            
          

Afzalliklari:

• Vazifalar va ishchilarni bir-biridan ajratadi
• Asinxron qayta ishlash imkonini beradi
• Juda masshtablanuvchi va xatolarga chidamli

Kamchiliklari:

• Xabarlar navbati tizimini sozlash va boshqarishni talab qiladi
• Ilova arxitekturasiga murakkablik qo'shadi
• Kechikishlarni keltirib chiqarishi mumkin

Global qo'llash misoli: Global ijtimoiy media platformasi rasmga ishlov berish, sentiment tahlili va bildirishnomalarni yetkazib berish kabi vazifalarni bajarish uchun xabarlar navbatidan foydalanishi mumkin. Foydalanuvchi rasmni yuklaganda, navbatga xabar yuboriladi. Turli geografik hududlardagi bir nechta ishchi jarayonlar ushbu xabarlarni iste'mol qiladi va kerakli qayta ishlashni amalga oshiradi. Bu butun dunyo bo'ylab foydalanuvchilarning eng yuqori trafik davrlarida ham vazifalarning samarali va ishonchli bajarilishini ta'minlaydi.

5. `p-map` kabi kutubxonalar

Bir nechta JavaScript kutubxonalari parallel qayta ishlashni soddalashtiradi va ishchilarni bevosita boshqarish murakkabliklarini yashiradi. `p-map` - bu qiymatlar massivini bir vaqtning o'zida promise'larga o'zgartirish uchun mashhur kutubxona. U asinxron iteratorlardan foydalanadi va siz uchun bir vaqtda ishlash darajasini boshqaradi.

Misol:

            const pMap = require('p-map');

const files = [
 'file1.txt',
 'file2.txt',
 'file3.txt',
 'file4.txt'
];

const mapper = async file => {
 // Asinxron operatsiyani simulyatsiya qilish
 await new Promise(resolve => setTimeout(resolve, 100));
 return `Qayta ishlandi: ${file}`;
};

(async () => {
 const result = await pMap(files, mapper, { concurrency: 2 });
 console.log(result);
 //=> ['Qayta ishlandi: file1.txt', 'Qayta ishlandi: file2.txt', 'Qayta ishlandi: file3.txt', 'Qayta ishlandi: file4.txt']
})();

            

              
                Copy
              
            
          

Afzalliklari:

• Massivlarni parallel qayta ishlash uchun oddiy API
• Bir vaqtda ishlash darajasini boshqaradi
• Promise'lar va async/await asosida qurilgan

Kamchiliklari:

• Asosiy ishchilarni boshqarish ustidan kamroq nazorat
• Juda murakkab vazifalar uchun mos kelmasligi mumkin

Global qo'llash misoli: Xalqaro tarjima xizmati hujjatlarni bir vaqtning o'zida bir nechta tillarga tarjima qilish uchun `p-map`dan foydalanishi mumkin. Har bir hujjat parallel ravishda qayta ishlanishi mumkin, bu esa umumiy tarjima vaqtini sezilarli darajada qisqartiradi. Bir vaqtda ishlash darajasi server resurslari va mavjud tarjima mexanizmlari soniga qarab sozlanishi mumkin, bu esa foydalanuvchilarning til ehtiyojlaridan qat'i nazar optimal unumdorlikni ta'minlaydi.

To'g'ri usulni tanlash

Parallel vazifalarni bajarish uchun eng yaxshi yondashuv ilovangizning o'ziga xos talablariga bog'liq. Quyidagi omillarni hisobga oling:

• Vazifalarning murakkabligi: Oddiy vazifalar uchun Web Workers yoki `p-map` yetarli bo'lishi mumkin. Murakkabroq vazifalar uchun Node.js Worker Threads yoki xabarlar navbati kerak bo'lishi mumkin.
• Aloqa talablari: Agar vazifalar tez-tez aloqa qilishlari kerak bo'lsa, umumiy xotira yoki xabar almashish talab qilinishi mumkin.
• Masshtablanuvchanlik: Yuqori darajada masshtablanuvchi ilovalar uchun xabarlar navbati yoki klasterlar eng yaxshi variant bo'lishi mumkin.
• Muhit: Brauzerda yoki Node.js muhitida ishlayotganingiz mavjud variantlarni belgilaydi.

Parallel vazifalarni bajarish uchun eng yaxshi amaliyotlar

Parallel vazifalaringiz samarali va ishonchli bo'lishini ta'minlash uchun quyidagi eng yaxshi amaliyotlarga rioya qiling:

• Oqimlar o'rtasidagi aloqani minimallashtiring: Oqimlar o'rtasidagi aloqa qimmat bo'lishi mumkin, shuning uchun uni minimallashtirishga harakat qiling.
• Umumiy o'zgaruvchan holatdan saqlaning: Umumiy o'zgaruvchan holat poyga holatlari va turg'unliklarga olib kelishi mumkin. Umumiy ma'lumotlarni himoya qilish uchun o'zgarmas ma'lumotlar tuzilmalari yoki sinxronizatsiya mexanizmlaridan foydalaning.
• Xatolarni chiroyli tarzda hal qiling: Ishchi oqimlaridagi xatolar butun ilovani ishdan chiqarishi mumkin. Buni oldini olish uchun to'g'ri xatolarni qayta ishlashni joriy qiling.
• Unumdorlikni kuzatib boring: Muammoli joylarni aniqlash va shunga mos ravishda optimallashtirish uchun parallel vazifalaringizning unumdorligini kuzatib boring. Node.js Inspector yoki brauzer ishlab chiquvchi vositalari kabi vositalar bebaho bo'lishi mumkin.
• Puxta sinovdan o'tkazing: Parallel kodingiz turli sharoitlarda to'g'ri va samarali ishlayotganiga ishonch hosil qilish uchun uni puxta sinovdan o'tkazing. Birlik testlari va integratsiya testlaridan foydalanishni ko'rib chiqing.

Xulosa

Parallel vazifa bajaruvchilar JavaScript ilovalarining unumdorligi va sezgirligini oshirish uchun kuchli vositadir. Vazifalarni bir nechta oqimlar yoki jarayonlar bo'ylab taqsimlash orqali siz bajarilish vaqtini sezilarli darajada qisqartirishingiz va foydalanuvchi tajribasini yaxshilashingiz mumkin. Murakkab veb-ilova yoki yuqori unumdorlikka ega server tomonidagi tizimni yaratayotgan bo'lsangiz ham, parallel vazifa bajaruvchilarni tushunish va ulardan foydalanish zamonaviy JavaScript dasturlash uchun zarurdir.

To'g'ri usulni ehtiyotkorlik bilan tanlab va eng yaxshi amaliyotlarga rioya qilish orqali siz bir vaqtda bajarishning to'liq salohiyatini ochishingiz va global auditoriyaga xizmat ko'rsatadigan haqiqatan ham masshtablanuvchi va samarali ilovalarni yaratishingiz mumkin.